home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1997 September / Macworld (1997-09).dmg / Serious Software / Cherwell Scientific Demos / pro Fit / pro Fit 5.0 demo (fpu).sea / pro Fit 5.0 demo (fpu) / External Modules / External modules sources / Pascal / FunctionTemplate.p < prev    next >
Text File  |  1996-03-07  |  9KB  |  242 lines
  1. {************************************************************************************}
  2. {  FunctionTemplate.p                                                     }
  3. {  use this template to create an external function                             }
  4. {  06.03.96:    added some more uses for compatibility with MWerks                 }
  5. {  30.12.96:    compatibility with MWerks 7 (68k+PPC) and ThinkPascal                 }
  6. {  27.1.95:    added compatibility for Metrowerks pascal CW 5 and universal headers 2.0a3 }
  7. {  26.9.94:    original version for 4.2.0                                     }
  8. {************************************************************************************}
  9.  
  10.  
  11. unit user;
  12.  
  13. interface
  14. {$IFC UNDEFINED THINK_PASCAL }
  15.     uses
  16.         proFit_interface, Types, Events, TextUtils, Memory;
  17. {$ELSEC}
  18.     uses
  19.         proFit_interface;
  20. {$ENDC}
  21.  
  22. {$MAIN}
  23.     procedure main (selector: integer; pb: ExtModulesParamBlockPtr);
  24.  
  25.  
  26.  
  27. implementation
  28.  
  29. { note: MPW users must make sure that the procedure main is at the beginning of the compiled code }
  30. { under Think Pascal, this is cared for by the compiler }
  31. { We let main call a function mainMain to make sure that the code starts with a jump to }
  32. { our entry point even when compiling under MPW Pascal }
  33.     procedure mainMain (selector: integer; pb: ExtModulesParamBlockPtr);
  34.     forward;
  35.     procedure main (selector: integer; pb: ExtModulesParamBlockPtr);
  36.  
  37.     begin
  38.         mainMain(selector, pb);
  39.     end;
  40.  
  41.  
  42.  
  43. {***********************************************************************************************}
  44.  
  45.     procedure SetUp (var moduleKind: integer;    { set moduleKind to isFunction or isProgram }
  46.                                     var name: Str255;             { the name of the program or function }
  47.                                     var requiredGlobals: longint;     { the number of bytes to be allocated in ExtModulesParamBlock.globals }
  48.                                         { set requiredGlobals to 0 if you don't use this feature }
  49.                                     pb: ExtModulesParamBlockPtr);    { the complete parameter block passed by pro Fit to the }
  50.                                         { routines defined in this file. In most cases it can be ignored }
  51. { SetUp is called once when the external module is linked to pro Fit }
  52.     begin
  53.         moduleKind := isFunction;        { this is a function }
  54.         name := '';                { set this string to the name of the program }
  55.         requiredGlobals := 0;        {leave this like it is now if you don't need to allocate global variable}
  56.                             { space using a pointer.}
  57.                             { set this to a pointer size if you want to use}
  58.                             { the pointer "globals" provided in ExtModulesParamBlock}
  59.     end;
  60.  
  61.  
  62.  
  63. {***********************************************************************************************}
  64.  
  65.     procedure InitializeFunc (var hasDerivatives: boolean;    { set this to true if you do calculate some derivatives (dyda[]) in the}
  66.                                                 { "Derivatives" function you define. Any derivatives you don't calculate will be calculated numerically by pro Fit }
  67.                                     var descr1stLine, descr2ndLine: Str255;     { The description text in the parameter window }
  68.                                     var numberOfParams: integer;             { the number of parameters of the function }
  69.                                     var a0: DefaultParamInfo;                 { the default names, values etc. of the parameters }
  70.                                     pb: ExtModulesParamBlockPtr);            { the complete parameter block passed by pro Fit to the }
  71.                                                                     { routines defined in this file. In most cases it can be ignored }
  72. { InitializeFunc is called once (after SetUp has been called) when the external module is linked to pro Fit }
  73. { Used to set all the information needed to describe a function }
  74.     begin
  75.         hasDerivatives := true; { leave this like it is now if you do calculate any "dyda" in the function "derivatives". }
  76.  
  77.         descr1stLine := '';         {write a description of the function in these two strings}
  78.         descr2ndLine := '';
  79.  
  80.         numberOfParams := 1;    {set this to the number of parameters used by the function}
  81.  
  82. {the parameters' default value, mode, name}
  83.         a0.value^[1] := 0;
  84.         a0.mode^[1] := inactive;
  85.         a0.name^[1] := '';            {set this string to the name of this parameter.}
  86.  
  87. {here you can also set parameter limits by setting a0.lowest^[1] and a0.highest^[1]    }
  88.     end;
  89.  
  90.  
  91. {***********************************************************************************************}
  92.  
  93.     function Check (ParamNo: integer;             { the parameter that was changed }
  94.                                     var a0: DefaultParamInfo;         { the default names, values etc. of the parameters }
  95.                                     pb: ExtModulesParamBlockPtr    { the complete parameter block passed by pro Fit to the}
  96.                                         { routines defined in this file. In most cases it can be ignored }
  97.                                     ): CheckPAnswer;
  98.     { Can be left emtpy (returning good) if not needed. }
  99.     { called when the user has changed a value in the parameters window. This routine }
  100.     { can then check if this parameters is fine. It can also change some of the }
  101.     { other entries in a0. The returned values can be: }
  102.     {    good:        return this value if you agree with the new parameter value }
  103.     {    update:        return this value if you want the parameters window }
  104.     {                to be updated because you changed some of the values in a0 }
  105.     {    bad:        return this value if you want the new parameter value to be refused }
  106.     begin
  107.         Check := good;
  108.     end;
  109.  
  110.  
  111.  
  112. {***********************************************************************************************}
  113.  
  114.     procedure First (a: ParamArray;             { the new parameters }
  115.                                     pb: ExtModulesParamBlockPtr);    { the complete parameter block passed by pro Fit to the}
  116.                                         { routines defined in this file. In most cases it can be ignored }
  117.  
  118. { Can be left emtpy if not needed. }
  119. { Called whenever the parameters were changed. Can be used to accelerate }
  120. { some calculations. See manual for more info }
  121.     begin
  122.     end;
  123.  
  124.  
  125.  
  126. {***********************************************************************************************}
  127.  
  128.     procedure Func (x: extended;                 { the x-value }
  129.                                     a: ParamArray;                { the parameters }
  130.                                     var y: extended;             { the y-value }
  131.                                     pb: ExtModulesParamBlockPtr);    { the complete parameter block passed by pro Fit to the}
  132.                                                             { routines defined in this file. In most cases it can be ignored }
  133. { called to calculate the y-value of your function for a given x and a given }
  134. { set of parameters }
  135.     begin
  136.         y := a[1] * x;
  137.     end;
  138.  
  139.  
  140.  
  141. {***********************************************************************************************}
  142.  
  143.     procedure Derivatives (x: extended;             { the x-value }
  144.                                     a: ParamArray;                 { the parameters }
  145.                                     var dyda: ParamArray;         { the derivatives }
  146.                                     pb: ExtModulesParamBlockPtr);    { the complete parameter block passed by pro Fit to the }
  147.                                                             { routines defined in this file. In most cases it can be ignored }
  148.  
  149.     { called to calculate the partial derivatives of the function with respect to }
  150.     { its parameters. The elements of the array "dyda[i]" must be set to the derivatives of    }
  151.     { the function with respect to parameter number "i". If any dyda[i] is not set by     }
  152.     { this function, then the derivatives will be calculated numerically by pro Fit. }
  153.     { If you set hasDerivatives to false in FuncInitialize, then ALL derivatives will always }
  154.     { be calcuated numerically by pro Fit, no matter what you do in the function "Derivatives" }
  155.     { If a derivative is too complicated to be calculated analytically, then don't set the }
  156.     { corresponding "dyda". pro Fit will notice this and calculate that derivative numerically. }
  157.     { If you are able to calculate the dyda analytically, do so! By doing this you will make }
  158.     { fitting much, much faster. }
  159.     begin
  160.     end;
  161.  
  162.  
  163.  
  164. {***********************************************************************************************}
  165.  
  166.     procedure Last (pb: ExtModulesParamBlockPtr);
  167. { Can be left emtpy if not needed. }
  168. { Called when calculating is through. See manual for more info }
  169.     begin
  170.     end;
  171.  
  172.  
  173. {***********************************************************************************************}
  174.  
  175.     procedure CleanUp (pb: ExtModulesParamBlockPtr);
  176.     { called when the function or program is removed from pro Fit's menus }
  177.     { in most cases, this function can be empty }
  178.     begin
  179.     end;
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187.  
  188.  
  189. {***********************************************************************************************}
  190.  
  191. { This is the main procedure through which all calls to the external module go.                    }
  192. { Main takes care of calling the right procedure with the right parameters depending on        }
  193. { the value of "selector".                                                                            }
  194. { You don't need to touch this procedure                                                            }
  195.     procedure mainMain (selector: integer; pb: ExtModulesParamBlockPtr);
  196.         var
  197.             oldA4: longint;
  198.     begin
  199. {$IFC NOT UNDEFINED SET_A4}
  200.         oldA4 := SetCurrentA4;
  201. {$ENDC}
  202.         Startup(pb);
  203.         case selector of
  204.             kSetup: 
  205.                 begin
  206.                     pb^.requiredGlobals := 0;
  207.                     pb^.versionNumber := VERSIONNUMBER;
  208.                     if sizeof(extended) = 10 then
  209.                         pb^.codeType := CPU68noFPU
  210.                     else if sizeof(extended) = 12 then
  211.                         pb^.codeType := CPU68FPU
  212.                     else
  213.                         pb^.codeType := CPUPowerPC;
  214.  
  215.                     SetUp(pb^.moduleKind, pb^.name, pb^.requiredGlobals, pb);
  216.                 end;
  217.             funcInitialize: 
  218.                 begin
  219.                     pb^.hasDerivatives := false;
  220.                     InitializeFunc(pb^.hasDerivatives, pb^.descr1, pb^.descr2, pb^.numberOfParams, pb^.a0, pb);
  221.                 end;
  222.             funcCheck: 
  223.                 pb^.answer := ord(Check(pb^.paramNo, pb^.a0, pb));
  224.             funcFirst: 
  225.                 First(pb^.a^, pb);
  226.             funcFunc: 
  227.                 Func(pb^.x^, pb^.a^, pb^.y^, pb);
  228.             funcDerivatives: 
  229.                 Derivatives(pb^.x^, pb^.a^, pb^.dyda^, pb);
  230.             funcLast: 
  231.                 Last(pb);
  232.             kcleanup: 
  233.                 CleanUp(pb);
  234.             otherwise
  235.         end;
  236. {$IFC NOT UNDEFINED SET_A4}
  237.         oldA4 := SetA4(oldA4);
  238. {$ENDC}
  239.     end;
  240.  
  241.  
  242. end.